home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / PASCAL / ALLSWAGS.ZIP / SWAGN-R.ZIP / NETWORK.SWG / 0037_Netware 3.11 API Library - File handling.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1996-11-29  |  20.0 KB  |  719 lines
  1. {
  2.             ╔══════════════════════════════════════════════════╗
  3.             ║     ┌╦═══╦┐┌╦═══╦┐┌╦═══╦┐┌╦═╗ ╦┐┌╦═══╦┐┌╔═╦═╗┐   ║
  4.             ║     │╠═══╩┘├╬═══╬┤└╩═══╦┐│║ ║ ║│├╬══      ║      ║
  5.             ║     └╩     └╩   ╩┘└╩═══╩┘└╩ ╚═╩┘└╩═══╩┘   ╩      ║
  6.             ║                                                  ║
  7.             ║     NetWare 3.11 API Library for Turbo Pascal    ║
  8.             ║                      by                          ║
  9.             ║                 S.Perevoznik                     ║
  10.             ║                     1996                         ║
  11.             ╚══════════════════════════════════════════════════╝
  12. }
  13.  
  14. Unit NetFile;
  15.  
  16.  
  17. Interface
  18.  
  19. Uses NetConv;
  20.  
  21.  
  22.  
  23.  
  24.  
  25. Const
  26.   TA_NONE       =  $00;
  27.   TA_READ       =  $01;
  28.   TA_WRITE      =  $02;
  29.   TA_OPEN       =  $04;
  30.   TA_CREATE     =  $08;
  31.   TA_DELETE     =  $10;
  32.   TA_OWNERSHIP  =  $20;
  33.   TA_SEARCH     =  $40;
  34.   TA_MODIFY     =  $80;
  35.   TA_ALL        =  $FF;
  36.  
  37. Const
  38.  
  39.  FA_NORMAL           = $00;
  40.  FA_READ_ONLY        = $01;
  41.  FA_HIDDEN           = $02;
  42.  FA_SYSTEM           = $04;
  43.  FA_EXECUTE_ONLY     = $08;
  44.  FA_DIRECTORY        = $10;
  45.  FA_NEEDS_ARCHIVED   = $20;
  46.  FA_SHAREABLE        = $80;
  47.  
  48.  
  49. Const
  50.  
  51.  FA_TRANSACTIONAL    = $10;
  52.  FA_INDEXED          = $20;
  53.  FA_READ_AUDIT       = $40;
  54.  FA_WRITE_AUDIT      = $80;
  55.  
  56. Function CreateDirectory( DirectoryHandle    : byte;
  57.                           DirectoryPath      : string;
  58.                           MaximumRightsMask  : byte) : byte;
  59.  
  60.  
  61. Function DeleteDirectory( DirectoryHandle    : byte;
  62.                           DirectoryPath      : string) : byte;
  63.  
  64.  
  65. Function RenameDirectory( DirectoryHandle  : byte;
  66.                           DirectoryPath    : string;
  67.                           NewDirectoryName : string):byte;
  68.  
  69.  
  70. Function SetDirectoryInformation( DirectoryHandle : byte;
  71.                                   DirectoryPath   : string;
  72.                                   NewCreationDateAndTime : longint;
  73.                                   NewOwnerObjectID : LongInt;
  74.                                   NewMaximumRightsMask : byte) : byte;
  75.  
  76.  
  77. Function GetDirectoryPath(DirectoryHandle     : byte;
  78.                           Var directoryPath   : string) : byte;
  79.  
  80.  
  81. Function GetVolumeNumber(VolumeName : string;
  82.                          Var VolumeNumber : integer) : byte;
  83.  
  84.  
  85. Function GetVolumeName(VolumeNumber : integer;
  86.                        Var VolumeName  : string) : byte;
  87.  
  88.  
  89.  
  90. Function PurgeErasedFiles : byte;
  91.  
  92.  
  93.  
  94. Function RestoreErasedFile(DriveHandle : byte;
  95.                            VolumeName  : string;
  96.                            Var ErasedFileName ,
  97.                                RestoredFileName : string) : byte;
  98.  
  99.  
  100. Function GetDirectoryHandle(Drive : byte;
  101.                             Var Handle : byte) : byte;
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110. Function SaveDirectoryHandle(DirectoryHandle : byte;
  111.                              Var SaveBuffer  : String) : byte;
  112.  
  113.  
  114. Function RestoreDirectoryHandle(SaveBuffer : string;
  115.                                  Var newDirectoryHandle : byte;
  116.                                  Var EffectiveRigthMask : Byte) : byte;
  117.  
  118.  
  119.  
  120. Function SetFileInformation( driveHandle            : byte;
  121.                              filePath               : string;
  122.                              searchAttributes       : byte;
  123.                              fileAttributes         : byte;
  124.                              extendedFileAttributes : byte;
  125.                              creationDate           : integer;
  126.                              lastAccessDate         : integer;
  127.                              lastUpdateDateAndTime  : LongInt;
  128.                              lastArchiveDateAndTime : LongInt;
  129.                              fileOwnerID            : LongInt) : byte;
  130.  
  131.  
  132. Function GetExtendedFileAttributes(FilePath : string;
  133.                                    Var Attr : byte) : byte;
  134.  
  135.  
  136.  
  137. Function SetExtendedFileAttributes(FilePath : string;
  138.                                    attr : byte) : byte;
  139.  
  140.  
  141.  
  142. Function AllocPermanentDirectoryHandle(DirectoryHandle:Byte;
  143.                                          DirectoryPath  :string;
  144.                                          DriveLetter    :char;
  145.                                          Var NewDirectoryHandle,
  146.                                          EffectiveRigthMask : byte):byte;
  147.  
  148.  
  149. Function AllocTemporaryDirectoryHandle(DirectoryHandle:Byte;
  150.                                          DirectoryPath  :string;
  151.                                          DriveLetter    :char;
  152.                                          Var NewDirectoryHandle,
  153.                                          EffectiveRigthMask : byte):byte;
  154.  
  155.  
  156. Procedure DeallocateDirectoryHandle(DirectoryHandle : byte);
  157.  
  158.  
  159.  
  160. Implementation
  161.  
  162. Uses Dos;
  163.  
  164. Function CreateDirectory( DirectoryHandle    : byte;
  165.                           DirectoryPath      : string;
  166.                           MaximumRightsMask  : byte) : byte;
  167.  
  168.  var
  169.    r : registers;
  170.    SendPacket  : array[0..261] of byte;
  171.    ReplyPacket : array[0..2] of byte;
  172.    WordPtr     : ^word;
  173. begin
  174.     SendPacket[2] := 10;
  175.     SendPacket[3] := directoryHandle;
  176.     SendPacket[4] := maximumRightsMask;
  177.     SendPacket[5] := Length(DirectoryPath);
  178.     Move(DirectoryPath[1],SendPacket[6],Length(DirectoryPath));
  179.     WordPtr  := addr(SendPacket);
  180.     WordPtr^ := Length(DirectoryPath)+4;
  181.     WordPtr  := addr(ReplyPacket);
  182.     WordPtr^ := 0;
  183.     r.BX := r.DS;
  184.     r.AH := $0E2;
  185.     r.DS := SEG(SendPacket);
  186.     r.SI := OFS(SendPacket);
  187.     r.ES := SEG(ReplyPacket);
  188.     r.DI := OFS(ReplyPacket);
  189.     intr($21,r);
  190.     r.DS := r.BX;
  191.     CreateDirectory := r.AL;
  192. end;
  193.  
  194. Function DeleteDirectory( DirectoryHandle    : byte;
  195.                           DirectoryPath      : string) : byte;
  196.  
  197.  var
  198.    r : registers;
  199.    SendPacket  : array[0..261] of byte;
  200.    ReplyPacket : array[0..2] of byte;
  201.    WordPtr     : ^word;
  202. begin
  203.     SendPacket[2] := 11;
  204.     SendPacket[3] := directoryHandle;
  205.     SendPacket[4] := 0;
  206.     SendPacket[5] := Length(DirectoryPath);
  207.     Move(DirectoryPath[1],SendPacket[6],Length(DirectoryPath));
  208.     WordPtr  := addr(SendPacket);
  209.     WordPtr^ := Length(DirectoryPath)+4;
  210.     WordPtr  := addr(ReplyPacket);
  211.     WordPtr^ := 0;
  212.     r.BX := r.DS;
  213.     r.AH := $0E2;
  214.     r.DS := SEG(SendPacket);
  215.     r.SI := OFS(SendPacket);
  216.     r.ES := SEG(ReplyPacket);
  217.     r.DI := OFS(ReplyPacket);
  218.     intr($21,r);
  219.     r.DS := r.BX;
  220.     DeleteDirectory := r.AL;
  221. end;
  222.  
  223. Function RenameDirectory( DirectoryHandle  : byte;
  224.                           DirectoryPath    : string;
  225.                           NewDirectoryName : string):byte;
  226.  
  227.  
  228.  var
  229.    r : registers;
  230.    SendPacket  : array[0..275] of byte;
  231.    ReplyPacket : array[0..2] of byte;
  232.    WordPtr     : ^word;
  233. begin
  234.     SendPacket[2] := 15;
  235.     SendPacket[3] := directoryHandle;
  236.     SendPacket[4] := Length(DirectoryPath);
  237.     Move(DirectoryPath[1],SendPacket[5],Length(DirectoryPath));
  238.     SendPacket[Length(DirectoryPath)+5] := Length(NewDirectoryName);
  239.     move(NewDirectoryName[1],SendPacket[6+Length(DirectoryPath)],Length(NewDirectoryName));
  240.     WordPtr  := addr(SendPacket);
  241.     WordPtr^ := Length(DirectoryPath)+4 + Length(NewDirectoryName);
  242.     WordPtr  := addr(ReplyPacket);
  243.     WordPtr^ := 0;
  244.     r.BX := r.DS;
  245.     r.AH := $0E2;
  246.     r.DS := SEG(SendPacket);
  247.     r.SI := OFS(SendPacket);
  248.     r.ES := SEG(ReplyPacket);
  249.     r.DI := OFS(ReplyPacket);
  250.     intr($21,r);
  251.     r.DS := r.BX;
  252.     REnameDirectory := r.AL;
  253. end;
  254.  
  255. Function SetDirectoryInformation( DirectoryHandle : byte;
  256.                                   DirectoryPath   : string;
  257.                                   NewCreationDateAndTime : longint;
  258.                                   NewOwnerObjectID : LongInt;
  259.                                   NewMaximumRightsMask : byte) : byte;
  260.  
  261.  var
  262.    r : registers;
  263.    SendPacket  : array[0..270] of byte;
  264.    ReplyPacket : array[0..2] of byte;
  265.    WordPtr     : ^word;
  266. begin
  267.   SendPacket[2] := 25;
  268.   SendPacket[3] := DirectoryHandle;
  269.   move(NewCreationDateAndTime,SendPacket[4],4);
  270.   NewOwnerObjectID := GetLong(addr(NewOwnerObjectID));
  271.   move(NewOwnerObjectID,SendPacket[8],4);
  272.   SendPacket[12] := newMaximumRightsMask;
  273.   SendPacket[13] := Length(DirectoryPath);
  274.   move(DirectoryPath[1],SendPacket[14],Length(DirectoryPath));
  275.     WordPtr  := addr(SendPacket);
  276.     WordPtr^ := Length(DirectoryPath)+12;
  277.     WordPtr  := addr(ReplyPacket);
  278.     WordPtr^ := 0;
  279.     r.BX := r.DS;
  280.     r.AH := $0E2;
  281.     r.DS := SEG(SendPacket);
  282.     r.SI := OFS(SendPacket);
  283.     r.ES := SEG(ReplyPacket);
  284.     r.DI := OFS(ReplyPacket);
  285.     intr($21,r);
  286.     r.DS := r.BX;
  287.     SetDirectoryInformation := r.AL;
  288. end;
  289.  
  290. Function GetDirectoryPath(DirectoryHandle     : byte;
  291.                           Var directoryPath   : string) : byte;
  292.  
  293.  var
  294.    r : registers;
  295.    SendPacket  : array[0..4] of byte;
  296.    ReplyPacket : array[0..258] of byte;
  297.    WordPtr     : ^word;
  298. begin
  299.   SendPacket[2] := 1;
  300.   SendPacket[3] := DirectoryHandle;
  301.     WordPtr  := addr(SendPacket);
  302.     WordPtr^ := 2;
  303.     WordPtr  := addr(ReplyPacket);
  304.     WordPtr^ := 256;
  305.     r.BX := r.DS;
  306.     r.AH := $0E2;
  307.     r.DS := SEG(SendPacket);
  308.     r.SI := OFS(SendPacket);
  309.     r.ES := SEG(ReplyPacket);
  310.     r.DI := OFS(ReplyPacket);
  311.     intr($21,r);
  312.     r.DS := r.BX;
  313.     GetDirectoryPath := r.AL;
  314.     if r.AL = 0 then
  315.       begin
  316.         move(ReplyPacket[3],DirectoryPath[1],ReplyPacket[2]);
  317.         move(ReplyPacket[2],DirectoryPath[0],1);
  318.       end;
  319. end;
  320.  
  321. Function GetVolumeNumber(VolumeName : string;
  322.                          Var VolumeNumber : integer) : byte;
  323.  
  324.  var
  325.    r : registers;
  326.    SendPacket  : array[0..19] of byte;
  327.    ReplyPacket : array[0..3] of byte;
  328.    WordPtr     : ^word;
  329. begin
  330.   SendPacket[2] := 5;
  331.   SendPacket[3] := Length(VolumeName);
  332.   move(VolumeName[1],SendPacket[4],Length(VolumeName));
  333.     WordPtr  := addr(SendPacket);
  334.     WordPtr^ := Length(VolumeName)+2;
  335.     WordPtr  := addr(ReplyPacket);
  336.     WordPtr^ := 1;
  337.     r.BX := r.DS;
  338.     r.AH := $0E2;
  339.     r.DS := SEG(SendPacket);
  340.     r.SI := OFS(SendPacket);
  341.     r.ES := SEG(ReplyPacket);
  342.     r.DI := OFS(ReplyPacket);
  343.     intr($21,r);
  344.     r.DS := r.BX;
  345.     GetVolumeNumber := r.AL;
  346.     if r.AL = 0 then
  347.       VolumeNumber := ReplyPacket[2];
  348.  end;
  349.  
  350.  
  351. Function GetVolumeName(VolumeNumber : integer;
  352.                        Var VolumeName  : string) : byte;
  353.  
  354.  
  355.  var
  356.    r : registers;
  357.    SendPacket  : array[0..4] of byte;
  358.    ReplyPacket : array[0..18] of byte;
  359.    WordPtr     : ^word;
  360.  
  361. begin
  362.    SendPacket[2] := 6;
  363.    SendPacket[3] := VolumeNumber;
  364.     WordPtr  := addr(SendPacket);
  365.     WordPtr^ := 2;
  366.     WordPtr  := addr(ReplyPacket);
  367.     WordPtr^ := 18;
  368.     r.BX := r.DS;
  369.     r.AH := $0E2;
  370.     r.DS := SEG(SendPacket);
  371.     r.SI := OFS(SendPacket);
  372.     r.ES := SEG(ReplyPacket);
  373.     r.DI := OFS(ReplyPacket);
  374.     intr($21,r);
  375.     r.DS := r.BX;
  376.     GetVolumeName := r.AL;
  377.     if r.AL = 0 then
  378.       begin
  379.         move(ReplyPacket[3],VolumeName[1],ReplyPacket[2]);
  380.         move(ReplyPacket[2],VolumeName[0],1);
  381.       end;
  382. end;
  383.  
  384. Function PurgeErasedFiles : byte;
  385.  
  386.  var
  387.    r : registers;
  388.    SendPacket  : array[0..2] of byte;
  389.    ReplyPacket : array[0..1] of byte;
  390.    WordPtr     : ^word;
  391. begin
  392.   SendPacket[2] := $10;
  393.     WordPtr  := addr(SendPacket);
  394.     WordPtr^ := 1;
  395.     WordPtr  := addr(ReplyPacket);
  396.     WordPtr^ := 0;
  397.     r.BX := r.DS;
  398.     r.AH := $0E2;
  399.     r.DS := SEG(SendPacket);
  400.     r.SI := OFS(SendPacket);
  401.     r.ES := SEG(ReplyPacket);
  402.     r.DI := OFS(ReplyPacket);
  403.     intr($21,r);
  404.     r.DS := r.BX;
  405.     PurgeErasedFiles := r.AL;
  406.  end;
  407.  
  408. Function RestoreErasedFile(DriveHandle : byte;
  409.                            VolumeName  : string;
  410.                            Var ErasedFileName ,
  411.                                RestoredFileName : string) : byte;
  412.  
  413.  var
  414.    r : registers;
  415.    SendPacket  : array[0..21] of byte;
  416.    ReplyPacket : array[0..32] of byte;
  417.    WordPtr     : ^word;
  418. begin
  419.   SendPacket[2] := $11;
  420.   SendPacket[3] := DriveHandle;
  421.   SendPacket[4] := Length(VolumeName);
  422.   move(VolumeName[1],SendPacket[5],Length(VolumeName));
  423.     WordPtr  := addr(SendPacket);
  424.     WordPtr^ := Length(VolumeName)+3;
  425.     WordPtr  := addr(ReplyPacket);
  426.     WordPtr^ := 30;
  427.     r.BX := r.DS;
  428.     r.AH := 226;
  429.     r.DS := SEG(SendPacket);
  430.     r.SI := OFS(SendPacket);
  431.     r.ES := SEG(ReplyPacket);
  432.     r.DI := OFS(ReplyPacket);
  433.     intr($21,r);
  434.     r.DS := r.BX;
  435.     RestoreErasedFile := r.AL;
  436.     if r.AL = 0 then
  437.       begin
  438.         move(ReplyPacket[2],ErasedFileName[1],15);
  439.         ErasedFileName[0] := chr(15);
  440.         move(ReplyPacket[17],RestoredFileName[1],15);
  441.         RestoredFileName[0] := chr(15);
  442.       end;
  443.  end;
  444.  
  445. Function GetDirectoryHandle(Drive : byte;
  446.                             Var Handle : byte) : byte;
  447. var r : registers;
  448. begin
  449.   r.AH := $E9;
  450.   r.AL := 0;
  451.   r.DH := 0;
  452.   r.DL := Drive;
  453.   intr($21,r);
  454.   Handle := r.AL;
  455.   GetDirectoryHandle := r.AH;
  456. end;
  457.  
  458. Function SaveDirectoryHandle(DirectoryHandle : byte;
  459.                              Var SaveBuffer  : String) : byte;
  460.  
  461.  
  462.  var
  463.    r : registers;
  464.    SendPacket  : array[0..4] of byte;
  465.    ReplyPacket : array[0..16] of byte;
  466.    WordPtr     : ^word;
  467. begin
  468.   SendPacket[2] := 23;
  469.   SendPacket[3] := DirectoryHandle;
  470.     WordPtr  := addr(SendPacket);
  471.     WordPtr^ := 2;
  472.     WordPtr  := addr(ReplyPacket);
  473.     WordPtr^ := 14;
  474.     r.BX := r.DS;
  475.     r.AH := 226;
  476.     r.DS := SEG(SendPacket);
  477.     r.SI := OFS(SendPacket);
  478.     r.ES := SEG(ReplyPacket);
  479.     r.DI := OFS(ReplyPacket);
  480.     intr($21,r);
  481.     r.DS := r.BX;
  482.     SaveDirectoryHandle := r.AL;
  483.     if r.AL = 0 then
  484.       begin
  485.         move(ReplyPacket[2],SaveBuffer,14);
  486.       end;
  487.  end;
  488.  
  489. Function RestoreDirectoryHandle(SaveBuffer : string;
  490.                                  Var newDirectoryHandle : byte;
  491.                                  Var EffectiveRigthMask : Byte) : byte;
  492.  
  493.  
  494.  var
  495.    r : registers;
  496.    SendPacket  : array[0..19] of byte;
  497.    ReplyPacket : array[0..4] of byte;
  498.    WordPtr     : ^word;
  499. begin
  500.   SendPacket[2] := 24;
  501.   SendPacket[3] := Length(SaveBuffer);
  502.   move(SaveBuffer[1],SendPacket[4],Length(SaveBuffer));
  503.     WordPtr  := addr(SendPacket);
  504.     WordPtr^ := 17;
  505.     WordPtr  := addr(ReplyPacket);
  506.     WordPtr^ := 2;
  507.     r.BX := r.DS;
  508.     r.AH := 226;
  509.     r.DS := SEG(SendPacket);
  510.     r.SI := OFS(SendPacket);
  511.     r.ES := SEG(ReplyPacket);
  512.     r.DI := OFS(ReplyPacket);
  513.     intr($21,r);
  514.     r.DS := r.BX;
  515.     RestoreDirectoryHandle := r.AL;
  516.     if r.AL = 0 then
  517.       begin
  518.         NewDirectoryHandle := ReplyPacket[2];
  519.         EffectiveRigthMask := ReplyPacket[3];
  520.       end;
  521.  end;
  522.  
  523. Function SetFileInformation( driveHandle            : byte;
  524.                              filePath               : string;
  525.                              searchAttributes       : byte;
  526.                              fileAttributes         : byte;
  527.                              extendedFileAttributes : byte;
  528.                              creationDate           : integer;
  529.                              lastAccessDate         : integer;
  530.                              lastUpdateDateAndTime  : LongInt;
  531.                              lastArchiveDateAndTime : LongInt;
  532.                              fileOwnerID            : LongInt) : byte;
  533.  
  534.  
  535.  var
  536.    r : registers;
  537.    SendPacket  : array[0..339] of byte;
  538.    ReplyPacket : array[0..2] of byte;
  539.    WordPtr     : ^word;
  540.    i           : integer;
  541.  
  542. begin
  543.   SendPacket[2] := 16;
  544.   SendPacket[3] := FileAttributes;
  545.   SendPacket[4] := ExtendedFileAttributes;
  546.   SendPacket[5] := 0;
  547.   SendPacket[6] := 0;
  548.   SendPacket[7] := 0;
  549.   SendPacket[8] := 0;
  550.   move(CreationDate,SendPacket[9],2);
  551.   move(LastAccessDate,SendPacket[11],2);
  552.   move(LastUpdateDateAndTime,SendPacket[13],4);
  553.   FileOwnerID := GetLong(addr(FileOwnerID));
  554.   move(FileOwnerID,SendPacket[17],4);
  555.   move(lastArchiveDateAndTime,SendPacket[21],4);
  556.   for i :=  25 to 80 do
  557.     SendPacket[i] := 0;
  558.   SendPacket[81] := DriveHandle;
  559.   SendPacket[82] := searchAttributes;
  560.   SendPacket[83] := Length(FilePath);
  561.   move(FilePath[1],SendPacket[84],Length(FilePath));
  562.     WordPtr  := addr(SendPacket);
  563.     WordPtr^ := Length(FilePath)+ 82;
  564.     WordPtr  := addr(ReplyPacket);
  565.     WordPtr^ := 0;
  566.     r.BX := r.DS;
  567.     r.AH := 227;
  568.     r.DS := SEG(SendPacket);
  569.     r.SI := OFS(SendPacket);
  570.     r.ES := SEG(ReplyPacket);
  571.     r.DI := OFS(ReplyPacket);
  572.     intr($21,r);
  573.     r.DS := r.BX;
  574.     SetFileInformation:= r.AL;
  575.  end;
  576.  
  577. Function GetExtendedFileAttributes(FilePath : string;
  578.                                    Var Attr : byte) : byte;
  579.  
  580.  
  581. var r : registers;
  582. begin
  583.   FilePath[Length(FilePath)+1] := chr(0);
  584.   r.BX := r.DS;
  585.   r.AH := $B6;
  586.   r.AL := 0;
  587.   r.DS := SEG(FilePath[1]);
  588.   r.DX := OFS(FilePath[1]);
  589.   intr($21,r);
  590.   r.DS := r.BX;
  591.   Attr := r.CL;
  592.   if (r.Flags and FCARRY ) = 0 then
  593.   GetExtendedFileAttributes := 0 else
  594.   GetExtendedFileAttributes := r.AL;
  595. end;
  596.  
  597.  
  598. Function SetExtendedFileAttributes(FilePath : string;
  599.                                    attr : byte) : byte;
  600.  
  601.  
  602. var r : registers;
  603. begin
  604.   FilePath[Length(FilePath)+1] := chr(0);
  605.   r.BX := r.DS;
  606.   r.AH := $B6;
  607.   r.AL := $01;
  608.   r.CL := Attr;
  609.   r.DS := SEG(FilePath[1]);
  610.   r.DX := OFS(FilePath[1]);
  611.   intr($21,r);
  612.   r.DS := r.BX;
  613.   if (r.Flags and FCARRY ) = 0 then
  614.   SetExtendedFileAttributes := 0 else
  615.   SetExtendedFileAttributes := r.AL;
  616. end;
  617.  
  618. Function AllocPermanentDirectoryHandle(DirectoryHandle:Byte;
  619.                                          DirectoryPath  :string;
  620.                                          DriveLetter    :char;
  621.                                          Var NewDirectoryHandle,
  622.                                          EffectiveRigthMask : byte):byte;
  623.  
  624.  
  625. Var
  626.   r : registers;
  627.   SendPacket  : array[0..261] of byte;
  628.   ReplyPacket : array[0..004] of byte;
  629.   WordPtr     : ^Word;
  630. begin
  631.   SendPacket[2] := $12;
  632.   SendPacket[3] := DirectoryHandle;
  633.   SendPacket[4] := Ord(DriveLetter);
  634.   move(DirectoryPath,SendPacket[5],Length(DirectoryPath)+1);
  635.   WordPtr  := addr(SendPacket);
  636.   WordPtr^ := Length(DirectoryPath)+4;
  637.   WordPtr  := addr(ReplyPacket);
  638.   WordPtr^ := 2;
  639.   r.BX := r.DS;
  640.   r.AH := $E2;
  641.   r.DS := SEG(SendPacket);
  642.   r.SI := OFS(SendPacket);
  643.   r.ES := SEG(ReplyPacket);
  644.   r.DI := OFS(ReplyPacket);
  645.   intr($21,r);
  646.   r.DS := r.BX;
  647.   AllocPermanentDirectoryHandle := r.AL;
  648.   if r.AL = 0 then
  649.     begin
  650.       NewDirectoryHandle := ReplyPacket[2];
  651.       EffectiveRigthMask := ReplyPacket[3];
  652.     end;
  653. end;
  654.  
  655.  
  656.  
  657. Function AllocTemporaryDirectoryHandle(DirectoryHandle:Byte;
  658.                                          DirectoryPath  :string;
  659.                                          DriveLetter    :char;
  660.                                          Var NewDirectoryHandle,
  661.                                          EffectiveRigthMask : byte):byte;
  662.  
  663. Var
  664.   r : registers;
  665.   SendPacket  : array[0..261] of byte;
  666.   ReplyPacket : array[0..004] of byte;
  667.   WordPtr     : ^Word;
  668. begin
  669.   SendPacket[2] := $13;
  670.   SendPacket[3] := DirectoryHandle;
  671.   SendPacket[4] := Ord(DriveLetter);
  672.   move(DirectoryPath,SendPacket[5],Length(DirectoryPath)+1);
  673.   WordPtr  := addr(SendPacket);
  674.   WordPtr^ := Length(DirectoryPath)+4;
  675.   WordPtr  := addr(ReplyPacket);
  676.   WordPtr^ := 2;
  677.   r.BX := r.DS;
  678.   r.AH := $E2;
  679.   r.DS := SEG(SendPacket);
  680.   r.SI := OFS(SendPacket);
  681.   r.ES := SEG(ReplyPacket);
  682.   r.DI := OFS(ReplyPacket);
  683.   intr($21,r);
  684.   r.DS := r.BX;
  685.   AllocTemporaryDirectoryHandle := r.AL;
  686.   if r.AL = 0 then
  687.     begin
  688.       NewDirectoryHandle := ReplyPacket[2];
  689.       EffectiveRigthMask := ReplyPacket[3];
  690.     end;
  691. end;
  692.  
  693. Procedure DeallocateDirectoryHandle(DirectoryHandle : byte);
  694.  
  695. Var
  696.   r : registers;
  697.   SendPacket  : array[0..4] of byte;
  698.   ReplyPacket : array[0..2] of byte;
  699.   WordPtr     : ^Word;
  700. begin
  701.   SendPacket[2] := $14;
  702.   SendPacket[3] := DirectoryHandle;
  703.   WordPtr  := addr(SendPacket);
  704.   WordPtr^ := 2;
  705.   WordPtr  := addr(ReplyPacket);
  706.   WordPtr^ := 0;
  707.   r.BX := r.DS;
  708.   r.AH := $E2;
  709.   r.DS := SEG(SendPacket);
  710.   r.SI := OFS(SendPacket);
  711.   r.ES := SEG(ReplyPacket);
  712.   r.DI := OFS(ReplyPacket);
  713.   intr($21,r);
  714.   r.DS := r.BX;
  715. end;
  716.  
  717.  
  718. End.
  719.